{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^∗$ should match a target distribution defined by taking the distribution for the next state $S_t+1$ and action $a^∗_{t+1} = \\pi^*(S_t+1)$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^*_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.nn.utils import clip_grad_norm_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=2)\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device),\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # gradient clipping\n",
    "        # https://pytorch.org/docs/stable/nn.html#torch.nn.utils.clip_grad_norm_\n",
    "        clip_grad_norm_(self.dqn.parameters(), 1.0, norm_type=1)\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"]).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgOEDNZQLJBYIASMET\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderOEDNZQLJBYIASMET\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animOEDNZQLJBYIASMET.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animOEDNZQLJBYIASMET.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectOEDNZQLJBYIASMET\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgOEDNZQLJBYIASMET\";\n",
       "    var slider_id = \"_anim_sliderOEDNZQLJBYIASMET\";\n",
       "    var loop_select_id = \"_anim_loop_selectOEDNZQLJBYIASMET\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animOEDNZQLJBYIASMET = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
